package com.ruike.alisurface.ui.payPage;

import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.ruike.alisurface.BuildConfig;
import com.ruike.alisurface.MyApplication;
import com.ruike.alisurface.R;
import com.ruike.alisurface.Serials.MsgEventBus;
import com.ruike.alisurface.base.BaseAty;
import com.ruike.alisurface.bean.CarGoodsBeans;
import com.ruike.alisurface.bean.OrderrBean;
import com.ruike.alisurface.bean.ShopDetailBean;
import com.ruike.alisurface.http.OtherApiHttp;
import com.ruike.alisurface.http.UrlHttpUtils;
import com.ruike.alisurface.http.WxPayHttp;
import com.ruike.alisurface.ui.adapter.PayCarListAdapter;
import com.ruike.alisurface.utils.MyCountDownTimer;
import com.ruike.alisurface.utils.ShareKey;
import com.ruike.alisurface.utils.ZXingUtils;
import com.voodoo.lib_utils.GsonUtils;
import com.voodoo.lib_utils.L;
import com.voodoo.lib_utils.ShareUtils;
import com.voodoo.lib_utils.imageLoader.ImageLoader;
import com.voodoo.lib_wechatpayface.ResultDataBean;
import com.voodoo.lib_wechatpayface.WeChatPayFace;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

import butterknife.BindView;
import butterknife.OnClick;

/**
 * Author：voodoo
 * CreateTime：2021/10/08 008 上午 10:31:36
 * Description：直接使用微信支付界面
 */
public class PayForWeChatFaceActivity extends BaseAty implements WeChatPayFace.OnWeChatSdkListener {

    @BindView(R.id.selectPay_goback_imgv)
    ImageView gobackImgv;
    @BindView(R.id.selectPay_countDown_tv)
    TextView countDownTv;
    @BindView(R.id.selectPay_goodsList_recv)
    RecyclerView goodsListRecv;
    @BindView(R.id.pay_type_content_imgv)
    ImageView payContentImgv;
    @BindView(R.id.pay_type_face_llayout)
    LinearLayout faceLlayout;
    @BindView(R.id.pay_type_qrcode_llayout)
    LinearLayout qrcodeLlayout;

    List<CarGoodsBeans> paycarlist; // 购物车中的数据
    int payType = 0; // 支付方式 0：刷脸下单  1：二维码扫码下单
    JSONArray mergeSlotJson; // 商品合并之后的一个JSON列表对象

    ShopDetailBean shopDetailBean; // 微信刷脸支付使用到的
    String payOrderId; // 订单ID
    String payTransactionId; // 交易ID
    long lastChangeTime; // 最后切换支付方式的时间
    MyCountDownTimer goBackCountDownTimer; // 返回按钮的可点与不可点
    MyCountDownTimer toPayCountDownTimer; // 去支付按钮的可点与不可点
    MyCountDownTimer pollingPayResultTimer; // 轮询支付结果计时器
    int pollingNumber = 0; // 轮询次数，主要的就是控制
    int maxPollingNumber = 200; // 最大轮询次数

    boolean isCameraStart = false; // 是否打开过微信摄像头
//    boolean isOtherPatResultSuccess = false; // 临时的变量，课代表上传人脸凭证已经成功返回或SDK已经成功返回

    @Override
    protected int getLayoutResId() {
        return R.layout.activity_pay_for_wechat_face;
    }

    @Override
    protected void initViews() {
        initTitleBar(false);
        // 设置调起摄像头按钮不可点击
        payContentImgv.setEnabled(false);
    }

    @Override
    protected void onResume() {
        super.onResume();
        startCountdownTimer(160, countDownTv, null);
    }

    @Override
    protected void initData() {
        // 刚进入界面的时候返回按钮不可点击
        gobackImgv.setEnabled(false);
        new MyCountDownTimer(3000, 3000) {
            @Override
            public void onTick(long millisUntilFinished) {
            }

            @Override
            public void onFinish() {
                gobackImgv.setEnabled(true);
            }
        }.start();

        // 查询购物车
        try {
            paycarlist = MyApplication.finalDbUtils.findAll(CarGoodsBeans.class);
        } catch (Exception e) {
            L.i("Exception==", e.getLocalizedMessage());
            showErrorTipAndFinsh("查询购物车异常！");
        }

        // 展示购物车列表到界面上
        if (paycarlist != null && paycarlist.size() > 0) {
            goodsListRecv.setLayoutManager(new GridLayoutManager(this, paycarlist.size()));
            goodsListRecv.setHasFixedSize(true);
            goodsListRecv.setAdapter(new PayCarListAdapter(this, paycarlist));
        } else {
            showErrorTipAndFinsh("查询的购物车为空，无法下单");
        }

//        // 合并下单参数并给 mergeSlotJson
//        mergeGoods();
        // 创建订单
        createOrder();
        // 设置支付方式展示View，之前是二维码和微信刷脸在一个界面切换，现在是只在该界面打开刷脸，无需切换到二维码支付
        setPayType();

    }

    @Override
    public void doEventBusResult(MsgEventBus event) {

    }

    @OnClick({R.id.payType_root_llayout, R.id.selectPay_goback_imgv, R.id.pay_type_content_imgv,
            R.id.pay_type_face_llayout, R.id.pay_type_qrcode_llayout})
    @Override
    public void onClick(View view) {
        super.onClick(view);
        switch (view.getId()) {
            case R.id.pay_type_content_imgv:
            case R.id.payType_root_llayout:
                L.i("根布局点击");
                break;
            case R.id.selectPay_goback_imgv:
                payContentImgv.setEnabled(false);
                L.i("点击返回按钮");
                startCountdownTimer(0, null, null);
                break;
            case R.id.pay_type_face_llayout:
            case R.id.pay_type_qrcode_llayout:
                // 当前是刷脸，再次点击刷脸，或者当前是二维码，再次点击二维码，直接返回，不执行下方代码逻辑
                if ((payType == 0 && view.getId() == R.id.pay_type_face_llayout) || (payType == 1 && view.getId() == R.id.pay_type_qrcode_llayout)) {
                    return;
                }
                // 拉开切换支付方式的时间间隔，防止多次创建订单和二维码导致内存异常
                if (System.currentTimeMillis() - lastChangeTime > 5_000) {
                    lastChangeTime = System.currentTimeMillis();
                    payType = view.getId() == R.id.pay_type_face_llayout ? 0 : 1;
                    createOrder();
                    setPayType();
                } else {
                    showErrorTip("请勿频繁切换支付方式");
                }
                break;
        }
    }

    /**
     * 合并商品信息
     * 返回：[{"SlotIndex":1,"Quantity":3},{"SlotIndex":3,"Quantity":5}]
     */
    public void mergeGoods() {

        Map<String, Integer> mergeMap = new HashMap<>();

        for (CarGoodsBeans carGoodsBean : paycarlist) {
            String slotIndex = carGoodsBean.getSlotIndexs();
            if (mergeMap.containsKey(slotIndex)) {
                int count = mergeMap.get(slotIndex);
                mergeMap.put(slotIndex, count + 1);
            } else {
                mergeMap.put(slotIndex, 1);
            }
        }

        JSONArray resultJSONArray = new JSONArray();

        try {
            for (Map.Entry<String, Integer> entry : mergeMap.entrySet()) {
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("SlotIndex", Integer.parseInt(entry.getKey()));
                jsonObject.put("Quantity", entry.getValue());
                resultJSONArray.put(jsonObject);
            }
        } catch (JSONException e) {
            return;
        }

        mergeSlotJson = resultJSONArray;
    }

    /**
     * 创建订单
     */
    private void createOrder() {
        showProgressDialog("正在创建订单...");
        switch (payType) {
            case 0:
                createPayFaceOrder();
                break;
        }
    }

    /**
     * 创建刷脸订单
     */
    private void createPayFaceOrder() {
        OtherApiHttp.expireCreateOrder(paycarlist.get(0).getProductid(), this);
//        WxPayHttp.createOrder(mergeSlotJson.toString(), this); // 下单，按照货道下单
    }

    /**
     * 选择支付方式
     */
    private void setPayType() {
        switch (payType) {
            case 0:
                cancelTimer(); // 将二维码付款轮询停掉
                ImageLoader.loadImage(this, R.drawable.img_wechat_face, payContentImgv);
                payContentImgv.setEnabled(true);
                faceLlayout.setSelected(true);
                qrcodeLlayout.setSelected(false);
                break;
        }
    }

    @Override
    public void onSuccess(String requestUrl, String resultJsonStr) {
        super.onSuccess(requestUrl, resultJsonStr);
        if (isFinishing()) {
            return;
        }
        // ================================================================================= 刷脸支付
        // 创建订单返回，调起刷脸
        if (OtherApiHttp.EXPIRE_CREATE_ORDER_URL.equals(requestUrl) || UrlHttpUtils.CREATE_ORDER_URL.equals(requestUrl)) { // 刷脸支付下单返回
            L.i("下单返回数据：" + resultJsonStr);
            try {
                JSONObject resultJson = new JSONObject(resultJsonStr);
                JSONObject dataObject = resultJson.optJSONObject("data");
                if (dataObject != null) {

                    shopDetailBean = new ShopDetailBean(dataObject.optString("id"));
                    shopDetailBean.setTotal_fee(dataObject.optDouble("total_fee"));
                    shopDetailBean.setPay_fee(dataObject.optDouble("total_fee"));

                    JSONArray detailArray = dataObject.optJSONArray("details");
                    List<ShopDetailBean.OrderDetailsBean> orderDetails = new ArrayList<>();
                    ShopDetailBean.OrderDetailsBean orderDetailsBean;
                    for (int i = 0; i < detailArray.length(); i++) {
                        JSONObject detailObject = detailArray.optJSONObject(i);
                        if (detailObject != null) {
                            orderDetailsBean = new ShopDetailBean.OrderDetailsBean();
                            orderDetailsBean.setQuantity(detailObject.optInt("quantity", 1));
                            orderDetailsBean.setSlotIndex(detailObject.optInt("slotIndex", 1));
                            orderDetailsBean.setSlotTypeId(detailObject.optInt("slotTypeId", 21003));
                            orderDetails.add(orderDetailsBean);
                        }
                    }

                    shopDetailBean.setDetailOrderList(orderDetails);
                    L.i("保存下来的出货数据 orderDetails:" + orderDetails.toString());

                    // 调起微信刷脸
                    startWeChatPayFace();

                }
            } catch (Exception e) {
                L.e("数据异常：" + e.toString());
            }
        }

        // 上传RawData返回
        if (UrlHttpUtils.GET_AUTH_INFO_URL.equals(requestUrl)) {
            try {
                JSONObject jsonObject = new JSONObject(resultJsonStr);
                ResultDataBean dataBean = GsonUtils.json2Model(jsonObject.getJSONObject("data").toString(), ResultDataBean.class);
                // 拿到返回值之后 使用回传的参数 调取摄像头，获取人脸凭证
                WeChatPayFace.getInstance().openCamera(dataBean, shopDetailBean.getOrderId(), String.valueOf((int) (shopDetailBean.getPay_fee() * 100)));
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        // 上传人脸凭证返回
        if (UrlHttpUtils.CREATE_MICROPAY_URL.equals(requestUrl)) {
            try {
                JSONObject jsonObject = new JSONObject(resultJsonStr);
                JSONObject dataJsonObject = jsonObject.optJSONObject("data");
                // 后台收到人脸凭证，返回订单和交易ID，这两个ID在后续轮询支付中会使用到
                if (dataJsonObject != null) {
                    // 轮询订单的时候会需要此两个id
                    // 订单ID：2021052614331705196502
                    payOrderId = dataJsonObject.optString("order_id");
                    // 交易ID：4200001024202105260847801232
                    payTransactionId = dataJsonObject.optString("transaction_id");
                    L.i("订单id(payOrderId):" + payOrderId + "   交易id(payTransactionId):" + payTransactionId);

                    // 获取到两个ID后开始轮询订单支付结果
                    pollingNumber = 0; // 轮询次数归零
                    pollingPayResult();

//                    // 如果其他方式有返回值了，此处的其他方式指的是微信的SDK返回的，那么直接开始轮询
//                    if (isOtherPatResultSuccess) {
//                        L.iTag("other", "微信SDK已经有返回值，开始轮询");
//                        // 开始轮询后台的支付结果
//                        pollingNumber = 0; // 轮询次数归零
//                        pollingPayResult();
//                    } else {
//                        // 否则的话将上传人脸凭证接口的值值为true，让接口返回值开启轮询
//                        L.iTag("other", "微信SDK没有返回值，将 isOtherPatResultSuccess 置为true");
//                        isOtherPatResultSuccess = true;
//                    }
                }
            } catch (JSONException e) {
                L.e("e:" + e.toString());
                e.printStackTrace();
            }
        }
        if (UrlHttpUtils.POLLING_WECHAT_PAY_RESULT.equals(requestUrl)) { // 轮询支付结果
            try {
                JSONObject jsonObject = new JSONObject(resultJsonStr);
                JSONObject dataJson = jsonObject.optJSONObject("data");
                if (dataJson != null) {
                    // 获取到支付结果之后进行下一步判断出货等
                    // 是否支付成功
                    boolean paySuccess = dataJson.optBoolean("pay_success");
                    // 展示弹窗
                    boolean needAlert = dataJson.optBoolean("need_alert");
                    // 是否需要继续轮询
                    boolean needPolling = dataJson.optBoolean("need_polling");
                    // 回传的消息信息
                    String msg = jsonObject.optString("msg");
                    L.e(String.format("解析到的数据：解析%s, 是否需要展示弹窗：%s, 是否需要继续轮询：%s, 回传的消息：%s", paySuccess, needAlert, needPolling, msg));
                    if (needAlert) {
                        if (paySuccess) {
                            showRightTip(msg);
                        } else {
                            showErrorTip(msg);
                        }
                    }
                    if (needPolling) {
                        pollingPayResult();
                    } else {
                        payResult(paySuccess);
                    }
                }
            } catch (JSONException e) {
            }
        }

        // ============================================================================= 刷脸支付 END

    }

    @Override
    public void onError(String requestUrl, String errorMsg) {
        super.onError(requestUrl, errorMsg);
        if (isFinishing()) {
            return;
        }
        // 创建订单失败
        if (UrlHttpUtils.CREATE_ORDER_URL.equals(requestUrl)) { // 刷脸支付下单返回
            payContentImgv.setEnabled(true);
            showErrorTipAndFinsh("创建订单异常");
            L.e("创建订单异常：" + errorMsg);
            return;
        }
        if (UrlHttpUtils.GET_AUTH_INFO_URL.equals(requestUrl)) { // 上传RawData返回
            payContentImgv.setEnabled(true);
            showErrorTipAndFinsh("上传RawData异常");
            L.e("上传RawData异常：" + errorMsg);
            return;
        }
        if (UrlHttpUtils.CREATE_MICROPAY_URL.equals(requestUrl)) { // 上传人脸凭证返回
            L.e("上传 face_code 失败：" + errorMsg);
            showErrorTipAndFinsh(errorMsg);
//            // 如果其他方式有返回值了，此处的其他方式指的是微信的SDK返回的，那么直接开始轮询
//            if (isOtherPatResultSuccess) {
//                L.iTag("other", "上传人脸接口已经有返回值，开始轮询");
//                // 开始轮询后台的支付结果
//                showErrorTip(errorMsg);
//                pollingNumber = 0; // 轮询次数归零
//                pollingPayResult();
////                payContentImgv.setEnabled(true);
////                showErrorTipAndFinsh("上传人脸凭证异常");
////                L.e("上传人脸凭证异常：" + errorMsg);
//            } else {
//                L.iTag("other", "上传人脸接口没有返回值，将 isOtherPatResultSuccess 值为true");
//                // 否则的话将上传人脸凭证接口的值值为true，让接口返回值开启轮询
//                isOtherPatResultSuccess = true;
//            }

            return;
        }
        if (UrlHttpUtils.POLLING_WECHAT_PAY_RESULT.equals(requestUrl)) { // 微信轮询支付结果
            L.e("轮询失败，次失败主要是网络原因或者后台将code置为了非0数字，所以继续下一次的查询：" + errorMsg);
            pollingPayResult();
        }
    }

    /**
     * 打开微信刷脸支付
     */
    private void startWeChatPayFace() {
        if (!isCameraStart) {
            isCameraStart = true;
            WeChatPayFace.getInstance().setOnWeChatSdkListener(this);
            WeChatPayFace.getInstance().getRawdata(); // 获取 RawData 获取到 RawData 之后上传后台
        } else {
            L.i("已经打开过微信摄像头，禁止重复打开");
        }
    }

    /**
     * 最终的结果
     *
     * @param isSuccess 是否支付成功
     */
    public void payResult(boolean isSuccess) {
        if (isSuccess) {
            L.i("订单支付支付成功，开始出货");
            Bundle bundle = new Bundle();
            bundle.putString("pay_type", "face");
            bundle.putSerializable("orderBeanData", shopDetailBean);
            startActivity(PayShowShopActivity.class, bundle);
            finish();
        } else {
            showErrorTipAndFinsh("订单支付支付失败");
        }
    }

    @Override
    public void weChatLog(String logMsg) {
        L.iTag("微信刷脸Log", logMsg);
    }

    @Override
    public void weChatSdkToast(String toastMsg) {
        showToast(toastMsg);
        if ("微信SDK未初始化成功".equals(toastMsg)) {
            if (ShareUtils.getInstance().getBoolean(ShareKey.IS_OPEN_QRCODE_PAY, true)) {
                startCountdownTimer(0, null, PayForQRCodeActivity.class);
            } else {
                showErrorTip("微信刷脸SDK未初始化成功");
                startCountdownTimer(3, null, SelectPayTypeActivity.class);
            }
        }
    }

    @Override
    public void getRawData(String rawData) {
        if (isFinishing()) {
            return;
        }
        // 获取到 RawData 之后上传后台
        L.i("获取到RawData，并上传");
        WxPayHttp.getAuthinfo(rawData, this);
    }

    @Override
    public void getFaceCode(String userOrderId, String faceCode, String openid) {
        if (isFinishing()) {
            return;
        }
        // 拿到人脸凭证上传给后台 然后等待支付结果
        WxPayHttp.createMicropay(userOrderId, faceCode, this);
    }

//    @Override
//    public void wxPayResult(boolean isPaySuccess) {
//        if (isFinishing()) {
//            return;
//        }
//        // 如果另一个返回了，此处判断的另一个是指拿到人脸凭证后请求后台接口，返回订单ID和交易ID
//        if (isOtherPatResultSuccess) {
//            L.iTag("other", "接口有返回值，直接开始轮询");
//            // 获取到支付结果之后，直接开始轮询后台，去查询后台的支付结果
//            pollingNumber = 0; // 轮询次数归零
//            pollingPayResult();
//        } else {
//            L.iTag("other", "接口无返回值，将 isOtherPatResultSuccess 设置为 true");
//            // 否则的话，只设置此变量为true，让接口的返回去开启轮询
//            isOtherPatResultSuccess = true;
//        }
//    }

    /**
     * 取消支付
     *
     * @param msg 取消原因
     */
    @Override
    public void wxPayCancel(boolean isSuccess, String msg) {
        if (!isSuccess) {
            if (ShareUtils.getInstance().getBoolean(ShareKey.IS_OPEN_QRCODE_PAY, true)) {
                startCountdownTimer(0, null, PayForQRCodeActivity.class);
            } else {
                showErrorTip("支付失败：" + msg);
                startCountdownTimer(3, null, SelectPayTypeActivity.class);
            }
        }
    }

    /**
     * 轮询支付结果
     */
    public void pollingPayResult() {
        showProgressDialog("查询支付结果中，请等待...");
        cancelPollingPayResultTimer();
        pollingPayResultTimer = new MyCountDownTimer(3000, 3000) {
            @Override
            public void onTick(long millisUntilFinished) {
            }

            @Override
            public void onFinish() {
                if (PayForWeChatFaceActivity.this.isFinishing()) {
                    L.e("Activity已经被结束，无需继续查询");
                } else {
                    getPayResult();
                }
            }
        };
        pollingPayResultTimer.start();
    }

    /**
     * 查询后台支付结果
     */
    private void getPayResult() {
        if (payOrderId != null && payTransactionId != null) {
            if (++pollingNumber <= maxPollingNumber) {
                L.i(String.format("第 %s 次查询订单状态", pollingNumber));
                WxPayHttp.getWechatPayResult(payOrderId, payTransactionId, PayForWeChatFaceActivity.this);
            } else {
                L.e(String.format("查询次数超过最大值：%s ==> %s，按照订单异常处理。", maxPollingNumber, maxPollingNumber));
            }
        } else {
            L.e("payOrderId 和 payTransactionId 值为空，所以无法去查询订单状态");
            payResult(false);
        }
    }

    // =================================================================================== 二维码支付

    Timer qrcodeTimer;
    TimerTask qrcodeTimerTask;

    private void cancelTimer() {
        if (qrcodeTimer != null) {
            qrcodeTimer.cancel();
        }
        if (qrcodeTimerTask != null) {
            qrcodeTimerTask.cancel();
        }
    }

    /**
     * 展示错误信息并计时返回主界面
     *
     * @param msg 要展示的信息
     */
    private void showErrorTipAndFinsh(String msg) {
        showErrorTip(msg);
        startCountdownTimer(3, null, null);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        L.i("刷脸支付页销毁");
        isCameraStart = false;
        removeProgressDialog();
        WeChatPayFace.getInstance().setOnWeChatSdkListener(null);
        cancelPollingPayResultTimer();
        if (goBackCountDownTimer != null) {
            goBackCountDownTimer.cancel();
            goBackCountDownTimer = null;
        }
        if (toPayCountDownTimer != null) {
            toPayCountDownTimer.cancel();
            toPayCountDownTimer = null;
        }
        cancelTimer();
    }

    /**
     * 停止轮询支付结果的计时
     */
    private void cancelPollingPayResultTimer() {
        if (pollingPayResultTimer != null) {
            pollingPayResultTimer.cancel();
            pollingPayResultTimer = null;
        }
    }

}
